com.eignex.koblas/sparse/host/basiclu/[jvm]BasicluSparseLu

BasicluSparseLu

class BasicluSparseLu(val config: BasicluConfig = BasicluConfig()) : F64SparseLuAdapter(source)

Sparse LU and Forrest-Tomlin basis updates backed by a host BASICLU.

Constructors

BasicluSparseLu

constructor(config: BasicluConfig = BasicluConfig())(source)

Properties

config

val config: BasicluConfig(source)

Policy for this backend instance.

name

open override val name: String(source)

A short backend identifier for diagnostics (e.g. "reference").

priority

open override val priority: Int(source)

Relative preference among the backends offered for one half (F64Blas, F64Decompositions, F64Kernels or a sparse counterpart). registerBackend picks the highest; the portable reference is 0.

supportsBasisUpdates

open override val supportsBasisUpdates: Boolean(source)

Whether factorBasis answers with a factorization that updates its factors in place. When false a replacement costs a factorization, so a caller pacing its own refactorizations has nothing left to pace.

isAvailable

open override val isAvailable: Boolean

Whether this backend can do work on this host. koblas's own implementations always can, so the default is true; a binding reports whether the library it calls resolved.

isPortable

open override val isPortable: Boolean

Whether this is koblas's own implementation rather than a binding to a host library. The compiled-in SIMD kernels are portable however fast they are; only something calling out counts as accelerated.

Functions

factorBasis

open override fun factorBasis(basis: F64SparseMatrix): F64BasisFactorization(source)

A basis is factorized natively at any size, since what a caller wants from BASICLU is the update that follows and the gate the general factorization answers to has nothing to say about it.

factor

override fun factor(a: F64SparseMatrix, equilibrate: Boolean = false, dropTolerance: Double = NO_DROP): F64SparseFactorization

Factorize the square a into something solvable. A singular matrix comes back as a factorization reporting singular rather than as an exception, with a failedAt counting elimination steps rather than naming a column: the step that fails is the one with no acceptable pivot left, so there is no column of a to attribute it to.

refactor

open fun refactor(previous: F64SparseFactorization, a: F64SparseMatrix, equilibrate: Boolean = false, dropTolerance: Double = NO_DROP): F64SparseFactorization

Factor a, reusing compatible state from previous when this backend can. The returned factorization supersedes previous, which must not be solved after this call. Backends that cannot reuse it answer as factor would.

solve

open fun solve(f: F64SparseFactorization, b: DoubleArray, transpose: Boolean = false): DoubleArray

solveInto into a fresh vector.

solveInto

open fun solveInto(f: F64SparseFactorization, b: DoubleArray, out: DoubleArray, transpose: Boolean = false, workspace: Workspace? = null): DoubleArray

Solve A·x = b from f into out, Aᵀ·x = b when transpose. The work belongs to the factorization; this is here so the seam reads the same from the sparse side as com.eignex.koblas .dense.F64Decompositions.solveInto does from the dense one.